home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / PROGRAMM / CC_C / 0566.ZIP / ARCLZW.MAC < prev    next >
Text File  |  1986-01-20  |  28KB  |  794 lines
  1. /*  ARC - Archive utility - ARCLZW
  2.  
  3. $define(tag,$$segment(@1,$$index(@1,=)+1))#
  4. $define(version,Version $tag(
  5. TED_VERSION DB =1.88), created on $tag(
  6. TED_DATE DB =01/20/86) at $tag(
  7. TED_TIME DB =16:47:04))#
  8. $undefine(tag)#
  9.     $version
  10.  
  11. (C) COPYRIGHT 1985 by System Enhancement Associates; ALL RIGHTS RESERVED
  12.  
  13.     By:  Thom Henderson
  14.  
  15.     Description:
  16.          This file contains the routines used to implement Lempel-Zev
  17.          data compression, which calls for building a coding table on
  18.          the fly.  This form of compression is especially good for encoding
  19.          files which contain repeated strings, and can often give dramatic
  20.          improvements over traditional Huffman SQueezing.
  21.  
  22.     Language:
  23.          Computer Innovations Optimizing C86
  24.  
  25.     Programming notes:
  26.          In this section I am drawing heavily on the COMPRESS program
  27.          from UNIX.  The basic method is taken from "A Technique for High
  28.          Performance Data Compression", Terry A. Welch, IEEE Computer
  29.          Vol 17, No 6 (June 1984), pp 8-19.  Also see "Knuth's Fundamental
  30.          Algorithms", Donald Knuth, Vol 3, Section 6.4.
  31.  
  32.          As best as I can tell, this method works by tracing down a hash
  33.          table of code strings where each entry has the property:
  34.  
  35.               if <string> <char> is in the table
  36.               then <string> is in the table.
  37. */
  38. #include <stdio.h>
  39. #include "arc.h"
  40.  
  41. /* definitions for older style crunching */
  42.  
  43. #define FALSE    0
  44. #define TRUE     !FALSE
  45. #define TABSIZE  4096
  46. #define NO_PRED  0xFFFF
  47. #define EMPTY    0xFFFF
  48. #define NOT_FND  0xFFFF
  49.  
  50. static unsigned int inbuf;             /* partial input code storage */
  51. static int sp;                         /* current stack pointer */
  52.  
  53. static struct entry                    /* string table entry format */
  54. {   char used;                         /* true when this entry is in use */
  55.     unsigned int next;                 /* ptr to next in collision list */
  56.     unsigned int predecessor;          /* code for preceeding string */
  57.     unsigned char follower;            /* char following string */
  58. }   string_tab[TABSIZE];               /* the code string table */
  59.  
  60.  
  61. /* definitions for the new dynamic Lempel-Zev crunching */
  62.  
  63. #define BITS   12                      /* maximum bits per code */
  64. #define HSIZE  5003                    /* 80% occupancy */
  65. #define INIT_BITS 9                    /* initial number of bits/code */
  66.  
  67. static int n_bits;                     /* number of bits/code */
  68. static int maxcode;                    /* maximum code, given n_bits */
  69. #define MAXCODE(n)      ((1<<(n)) - 1) /* maximum code calculation */
  70. static int maxcodemax =  1 << BITS;    /* largest possible code (+1) */
  71.  
  72. static char buf[BITS];                 /* input/output buffer */
  73.  
  74. static unsigned char lmask[9] =        /* left side masks */
  75. {   0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00 };
  76. static unsigned char rmask[9] =        /* right side masks */
  77. {   0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};
  78.  
  79. static int offset;                     /* byte offset for code output */
  80. static long in_count;                  /* length of input */
  81. static long bytes_out;                 /* length of compressed output */
  82. static unsigned int ent;
  83.  
  84. /* To save much memory (which we badly need at this point), we overlay
  85.  * the table used by the previous version of Lempel-Zev with those used
  86.  * by the new version.  Since no two of these routines will be used
  87.  * together, we can safely do this.  Note that the tables used for Huffman
  88.  * squeezing may NOT overlay these, since squeezing and crunching are done
  89.  * in parallel.
  90.  */
  91.  
  92. static long *htab = string_tab;        /* hash code table   (crunch) */
  93. static unsigned int codetab[HSIZE];    /* string code table (crunch) */
  94.  
  95. static unsigned int *prefix = codetab; /* prefix code table (uncrunch) */
  96. static unsigned char *suffix = string_tab;  /* suffix table (uncrunch) */
  97.  
  98. static int free_ent;                   /* first unused entry */
  99. static int firstcmp;                   /* true at start of compression */
  100. static unsigned char stack[HSIZE];     /* local push/pop stack */
  101.  
  102. /*
  103.  * block compression parameters -- after all codes are used up,
  104.  * and compression rate changes, start over.
  105.  */
  106.  
  107. static int clear_flg;
  108. static long ratio;
  109. #define CHECK_GAP 10000                /* ratio check interval */
  110. static long checkpoint;
  111.  
  112. /*
  113.  * the next two codes should not be changed lightly, as they must not
  114.  * lie within the contiguous general code space.
  115.  */
  116. #define FIRST   257                    /* first free entry */
  117. #define CLEAR   256                    /* table clear output code */
  118.  
  119. static cl_block(t)                     /* table clear for block compress */
  120. FILE *t;                               /* our output file */
  121. {
  122.     long int rat;
  123.  
  124.     checkpoint = in_count + CHECK_GAP;
  125.  
  126.     if(in_count > 0x007fffff)          /* shift will overflow */
  127.     {    rat = bytes_out >> 8;
  128.          if(rat == 0)                  /* Don't divide by zero */
  129.               rat = 0x7fffffff;
  130.          else rat = in_count / rat;
  131.     }
  132.     else rat = (in_count<<8)/bytes_out;/* 8 fractional bits */
  133.  
  134.     if(rat > ratio)
  135.          ratio = rat;
  136.     else
  137.     {    ratio = 0;
  138.          setmem(htab,HSIZE*sizeof(long),0xff);
  139.          free_ent = FIRST;
  140.          clear_flg = 1;
  141.          putcode(CLEAR,t);
  142.     }
  143. }
  144.  
  145. /*****************************************************************
  146.  *
  147.  * Output a given code.
  148.  * Inputs:
  149.  *      code:   A n_bits-bit integer.  If == -1, then EOF.  This assumes
  150.  *              that n_bits =< (long)wordsize - 1.
  151.  * Outputs:
  152.  *      Outputs code to the file.
  153.  * Assumptions:
  154.  *      Chars are 8 bits long.
  155.  * Algorithm:
  156.  *      Maintain a BITS character long buffer (so that 8 codes will
  157.  * fit in it exactly).  When the buffer fills up empty it and start over.
  158.  */
  159.  
  160. static putcode(code,t)                 /* output a code */
  161. int code;                              /* code to output */
  162. FILE *t;                               /* where to put it */
  163. {
  164.     int r_off = offset;                /* right offset */
  165.     int bits = n_bits;                 /* bits to go */
  166.     char *bp = buf;                    /* buffer pointer */
  167.     int n;                             /* index */
  168.  
  169.     if(code >= 0)                      /* if a real code */
  170.     {    /*
  171.           * Get to the first byte.
  172.           */
  173.          bp += (r_off >> 3);
  174.          r_off &= 7;
  175.  
  176.          /*
  177.           * Since code is always >= 8 bits, only need to mask the first
  178.           * hunk on the left.
  179.           */
  180.          *bp = (*bp&rmask[r_off]) | (code<<r_off) & lmask[r_off];
  181.          bp++;
  182.          bits -= (8 - r_off);
  183.          code >>= (8 - r_off);
  184.  
  185.          /* Get any 8 bit parts in the middle (<=1 for up to 16 bits). */
  186.          if(bits >= 8)
  187.          {    *bp++ = code;
  188.               code >>= 8;
  189.               bits -= 8;
  190.          }
  191.  
  192.          /* Last bits. */
  193.          if(bits)
  194.               *bp = code;
  195.  
  196.          offset += n_bits;
  197.  
  198.          if(offset == (n_bits << 3))
  199.          {    bp = buf;
  200.               bits = n_bits;
  201.               bytes_out += bits;
  202.               do
  203.                    putc_pak(*bp++,t);
  204.               while(--bits);
  205.               offset = 0;
  206.          }
  207.  
  208.          /*
  209.           * If the next entry is going to be too big for the code size,
  210.           * then increase it, if possible.
  211.           */
  212.          if(free_ent>maxcode || clear_flg>0)
  213.          {    /*
  214.                * Write the whole buffer, because the input side won't
  215.                * discover the size increase until after it has read it.
  216.                */
  217.               if(offset > 0)
  218.               {    bp = buf;           /* reset pointer for writing */
  219.                    bytes_out += n = n_bits;
  220.                    while(n--)
  221.                         putc_pak(*bp++,t);
  222.               }
  223.               offset = 0;
  224.  
  225.               if(clear_flg)            /* reset if clearing */
  226.               {    maxcode = MAXCODE(n_bits = INIT_BITS);
  227.                    clear_flg = 0;
  228.               }
  229.               else                     /* else use more bits */
  230.               {    n_bits++;
  231.                    if(n_bits == BITS)
  232.                         maxcode = maxcodemax;
  233.                    else
  234.                         maxcode = MAXCODE(n_bits);
  235.               }
  236.          }
  237.     }
  238.  
  239.     else                               /* dump the buffer on EOF */
  240.     {    bytes_out += n = (offset+7) / 8;
  241.  
  242.          if(offset > 0)
  243.               while(n--)
  244.                    putc_pak(*bp++,t);
  245.          offset = 0;
  246.     }
  247. }
  248.  
  249. /*****************************************************************
  250.  *
  251.  * Read one code from the standard input.  If EOF, return -1.
  252.  * Inputs:
  253.  *      cmpin
  254.  * Outputs:
  255.  *      code or -1 is returned.
  256.  */
  257.  
  258. static int getcode(f)                  /* get a code */
  259. FILE *f;                               /* file to get from */
  260. {
  261.     int code;
  262.     static int offset = 0, size = 0;
  263.     int r_off, bits;
  264.     unsigned char *bp = buf;
  265.  
  266.     if(clear_flg > 0 || offset >= size || free_ent > maxcode)
  267.     {    /*
  268.           * If the next entry will be too big for the current code
  269.           * size, then we must increase the size.  This implies reading
  270.           * a new buffer full, too.
  271.           */
  272.          if(free_ent > maxcode)
  273.          {    n_bits++;
  274.               if(n_bits == BITS)
  275.                    maxcode = maxcodemax;    /* won't get any bigger now */
  276.               else maxcode = MAXCODE(n_bits);
  277.          }
  278.          if(clear_flg > 0)
  279.          {    maxcode = MAXCODE(n_bits = INIT_BITS);
  280.               clear_flg = 0;
  281.          }
  282.  
  283.          for(size=0; size<n_bits; size++)
  284.          {    if((code=getc_unp(f))==EOF)
  285.                    break;
  286.               else buf[size] = code;
  287.          }
  288.          if(size <= 0)
  289.               return -1;               /* end of file */
  290.  
  291.          offset = 0;
  292.          /* Round size down to integral number of codes */
  293.          size = (size << 3)-(n_bits - 1);
  294.     }
  295.     r_off = offset;
  296.     bits = n_bits;
  297.  
  298.     /*
  299.      * Get to the first byte.
  300.      */
  301.     bp +=(r_off >> 3);
  302.     r_off &= 7;
  303.  
  304.     /* Get first part (low order bits) */
  305.     code = (*bp++ >> r_off);
  306.     bits -= 8 - r_off;
  307.     r_off = 8 - r_off;                 /* now, offset into code word */
  308.  
  309.     /* Get any 8 bit parts in the middle (<=1 for up to 16 bits). */
  310.     if(bits >= 8)
  311.     {    code |= *bp++ << r_off;
  312.          r_off += 8;
  313.          bits -= 8;
  314.     }
  315.     /* high order bits. */
  316.     code |= (*bp & rmask[bits]) << r_off;
  317.     offset += n_bits;
  318.  
  319.     return code;
  320. }
  321.  
  322. /*
  323.  * compress a file
  324.  *
  325.  * Algorithm:  use open addressing double hashing (no chaining) on the
  326.  * prefix code / next character combination.  We do a variant of Knuth's
  327.  * algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
  328.  * secondary probe.  Here, the modular division first probe is gives way
  329.  * to a faster exclusive-or manipulation.  Also do block compression with
  330.  * an adaptive reset, where the code table is cleared when the compression
  331.  * ratio decreases, but after the table fills.  The variable-length output
  332.  * codes are re-sized at this point, and a special CLEAR code is generated
  333.  * for the decompressor.
  334.  */
  335.  
  336. init_cm(f,t)                           /* initialize for compression */
  337. FILE *f;                               /* file we will be compressing */
  338. FILE *t;                               /* where we will put it */
  339. {
  340.     offset = 0;
  341.     bytes_out = 1;
  342.     clear_flg = 0;
  343.     ratio = 0;
  344.     in_count = 1;
  345.     checkpoint = CHECK_GAP;
  346.     maxcode = MAXCODE(n_bits = INIT_BITS);
  347.     free_ent = FIRST;
  348.     setmem(htab,HSIZE*sizeof(long),0xff);
  349.     n_bits = INIT_BITS;                /* set starting code size */
  350.  
  351.     putc_pak(BITS,t);                  /* note our max code length */
  352.  
  353.     firstcmp = 1;                      /* next byte will be first */
  354. }
  355.  
  356. putc_cm(c,t)                           /* compress a character */
  357. unsigned char c;                       /* character to compress */
  358. FILE *t;                               /* where to put it */
  359. {
  360.     static long fcode;
  361.     static int hshift;
  362.     int i;
  363.     int disp;
  364.  
  365.     if(firstcmp)                       /* special case for first byte */
  366.     {    ent = c;                      /* remember first byte */
  367.  
  368.          hshift = 0;
  369.          for(fcode=(long)HSIZE;  fcode<65536L; fcode*=2L)
  370.               hshift++;
  371.          hshift = 8 - hshift;          /* set hash code range bound */
  372.  
  373.          firstcmp = 0;                 /* no longer first */
  374.          return;
  375.     }
  376.  
  377.     in_count++;
  378.     fcode =(long)(((long)c << BITS)+ent);
  379.     i = (c<<hshift)^ent;               /* xor hashing */
  380.  
  381.     if(htab[i]==fcode)
  382.     {    ent = codetab[i];
  383.          return;
  384.     }
  385.     else if(htab[i]<0)                 /* empty slot */
  386.          goto nomatch;
  387.     disp = HSIZE - i;                  /* secondary hash (after G.Knott) */
  388.     if(i == 0)
  389.          disp = 1;
  390.  
  391. probe:
  392.     if((i -= disp) < 0)
  393.          i += HSIZE;
  394.  
  395.     if(htab[i] == fcode)
  396.     {    ent = codetab[i];
  397.          return;
  398.     }
  399.     if(htab[i] > 0)
  400.          goto probe;
  401.  
  402. nomatch:
  403.     putcode(ent,t);
  404.     ent = c;
  405.     if(free_ent < maxcodemax)
  406.     {    codetab[i] = free_ent++;      /* code -> hashtable */
  407.          htab[i] = fcode;
  408.     }
  409.     else if((long int)in_count >= checkpoint)
  410.          cl_block(t);
  411. }
  412.  
  413. long pred_cm(t)                        /* finish compressing a file */
  414. FILE *t;                               /* where to put it */
  415. {
  416.     putcode(ent,t);                    /* put out the final code */
  417.     putcode(-1,t);                     /* tell output we are done */
  418.  
  419.     return bytes_out;                  /* say how big it got */
  420. }
  421.  
  422. /*
  423.  * Decompress a file.  This routine adapts to the codes in the file
  424.  * building the string table on-the-fly; requiring no table to be stored
  425.  * in the compressed file.  The tables used herein are shared with those of
  426.  * the compress() routine.  See the definitions above.
  427.  */
  428.  
  429. decomp(f,t)                            /* decompress a file */
  430. FILE *f;                               /* file to read codes from */
  431. FILE *t;                               /* file to write text to */
  432. {
  433.     unsigned char *stackp;
  434.     int finchar;
  435.     int code, oldcode, incode;
  436.  
  437.     if((code=getc_unp(f))!=BITS)
  438.          abort("File packed with %d bits, I can only handle %d",code,BITS);
  439.  
  440.     n_bits = INIT_BITS;                /* set starting code size */
  441.     clear_flg = 0;
  442.  
  443.     /*
  444.      * As above, initialize the first 256 entries in the table.
  445.      */
  446.     maxcode = MAXCODE(n_bits=INIT_BITS);
  447.     for(code = 255; code >= 0; code--)
  448.     {    prefix[code] = 0;
  449.          suffix[code] = (unsigned char)code;
  450.     }
  451.     free_ent = FIRST;
  452.  
  453.     finchar = oldcode = getcode(f);
  454.     if(oldcode == -1)                  /* EOF already? */
  455.          return;                       /* Get out of here */
  456.     putc_ncr((char)finchar,t);         /* first code must be 8 bits=char */
  457.     stackp = stack;
  458.  
  459.     while((code = getcode(f))> -1)
  460.     {    if(code==CLEAR)
  461.          {    for(code = 255; code >= 0; code--)
  462.                    prefix[code] = 0;
  463.               clear_flg = 1;
  464.               free_ent = FIRST - 1;
  465.               if((code=getcode(f))==-1)/* O, untimely death! */
  466.                    break;
  467.          }
  468.          incode = code;
  469.          /*
  470.           * Special case for KwKwK string.
  471.           */
  472.          if(code >= free_ent)
  473.          {    *stackp++ = finchar;
  474.               code = oldcode;
  475.          }
  476.  
  477.          /*
  478.           * Generate output characters in reverse order
  479.           */
  480.          while(code >= 256)
  481.          {    *stackp++ = suffix[code];
  482.               code = prefix[code];
  483.          }
  484.          *stackp++ = finchar = suffix[code];
  485.  
  486.          /*
  487.           * And put them out in forward order
  488.           */
  489.          do
  490.               putc_ncr(*--stackp,t);
  491.          while(stackp > stack);
  492.  
  493.          /*
  494.           * Generate the new entry.
  495.           */
  496.          if((code=free_ent) < maxcodemax)
  497.          {    prefix[code] = (unsigned short)oldcode;
  498.               suffix[code] = finchar;
  499.               free_ent = code+1;
  500.          }
  501.          /*
  502.           * Remember previous code.
  503.           */
  504.          oldcode = incode;
  505.     }
  506. }
  507.  
  508.  
  509. /*************************************************************************
  510.  * Please note how much trouble it can be to maintain upwards            *
  511.  * compatibility.  All that follows is for the sole purpose of unpacking *
  512.  * files which were packed using an older method.                        *
  513.  *************************************************************************/
  514.  
  515.  
  516. /*  The h() pointer points to the routine to use for calculating a hash
  517.     value.  It is set in the init routines to point to either of oldh()
  518.     or newh().
  519.  
  520.     oldh() calculates a hash value by taking the middle twelve bits
  521.     of the square of the key.
  522.  
  523.     newh() works somewhat differently, and was tried because it makes
  524.     ARC about 23% faster.  This approach was abandoned because dynamic
  525.     Lempel-Zev (above) works as well, and packs smaller also.  However,
  526.     inadvertent release of a developmental copy forces us to leave this in.
  527. */
  528.  
  529. static unsigned (*h)();                /* pointer to hash function */
  530.  
  531. static unsigned oldh(pred,foll)        /* old hash function */
  532. unsigned int pred;                     /* code for preceeding string */
  533. unsigned char foll;                    /* value of following char */
  534. {
  535.     long local;                        /* local hash value */
  536.  
  537.     local = (pred + foll) | 0x0800;    /* create the hash key */
  538.     local *= local;                    /* square it */
  539.     return (local >> 6) & 0x0FFF;      /* return the middle 12 bits */
  540. }
  541.  
  542. static unsigned newh(pred,foll)        /* new hash function */
  543. unsigned int pred;                     /* code for preceeding string */
  544. unsigned char foll;                    /* value of following char */
  545. {
  546.     return ((pred+foll)*15073)&0xFFF;  /* faster hash */
  547. }
  548.  
  549. /*  The eolist() function is used to trace down a list of entries with
  550.     duplicate keys until the last duplicate is found.
  551. */
  552.  
  553. static unsigned eolist(index)          /* find last duplicate */
  554. unsigned int index;
  555. {
  556.     int temp;
  557.  
  558.     while(temp=string_tab[index].next) /* while more duplicates */
  559.          index = temp;
  560.  
  561.     return index;
  562. }
  563.  
  564. /*  The hash() routine is used to find a spot in the hash table for a new
  565.     entry.  It performs a "hash and linear probe" lookup, using h() to
  566.     calculate the starting hash value and eolist() to perform the linear
  567.     probe.  This routine DOES NOT detect a table full condition.  That
  568.     MUST be checked for elsewhere.
  569. */
  570.  
  571. static unsigned hash(pred,foll)        /* find spot in the string table */
  572. unsigned int pred;                     /* code for preceeding string */
  573. unsigned char foll;                    /* char following string */
  574. {
  575.     unsigned int local, tempnext;      /* scratch storage */
  576.     struct entry *ep;                  /* allows faster table handling */
  577.  
  578.     local = (*h)(pred,foll);           /* get initial hash value */
  579.  
  580.     if(!string_tab[local].used)        /* if that spot is free */
  581.          return local;                 /* then that's all we need */
  582.  
  583.     else                               /* else a collision has occured */
  584.     {    local = eolist(local);        /* move to last duplicate */
  585.  
  586.          /*   We must find an empty spot. We start looking 101 places
  587.               down the table from the last duplicate.
  588.          */
  589.  
  590.          tempnext = (local+101) & 0x0FFF;
  591.          ep = &string_tab[tempnext];   /* initialize pointer */
  592.  
  593.          while(ep->used)               /* while empty spot not found */
  594.          {    if(++tempnext==TABSIZE)  /* if we are at the end */
  595.               {    tempnext = 0;       /* wrap to beginning of table*/
  596.                    ep = string_tab;
  597.               }
  598.               else ++ep;               /* point to next element in table */
  599.          }
  600.  
  601.          /*   local still has the pointer to the last duplicate, while
  602.               tempnext has the pointer to the spot we found.  We use
  603.               this to maintain the chain of pointers to duplicates.
  604.          */
  605.  
  606.          string_tab[local].next = tempnext;
  607.  
  608.          return tempnext;
  609.     }
  610. }
  611.  
  612. /*  The unhash() function is used to search the hash table for a given key.
  613.     Like hash(), it performs a hash and linear probe search.  It returns
  614.     either the number of the entry (if found) or NOT_FND (if not found).
  615. */
  616.  
  617. static unsigned unhash(pred,foll)      /* search string table for a key */
  618. unsigned int pred;                     /* code of preceeding string */
  619. unsigned char foll;                    /* character following string */
  620. {
  621.     unsigned int local, offset;        /* scratch storage */
  622.     struct entry *ep;                  /* this speeds up access */
  623.  
  624.     local = (*h)(pred,foll);           /* initial hash */
  625.  
  626.     while(1)
  627.     {    ep = &string_tab[local];      /* speed up table access */
  628.  
  629.          if((ep->predecessor==pred) && (ep->follower==foll))
  630.               return local;            /* we have a match */
  631.  
  632.          if(!ep->next)                 /* if no more duplicates */
  633.               return NOT_FND;          /* then key is not listed */
  634.  
  635.          local = ep->next;             /* move on to next duplicate */
  636.     }
  637. }
  638.  
  639. /*  The init_tab() routine is used to initialize our hash table.
  640.     You realize, of course, that "initialize" is a complete misnomer.
  641. */
  642.  
  643. static init_tab()                      /* set ground state in hash table */
  644. {
  645.     unsigned int i;                    /* table index */
  646.  
  647.     setmem((char *)string_tab,sizeof(string_tab),0);
  648.  
  649.     for(i=0; i<256; i++)               /* list all single byte strings */
  650.          upd_tab(NO_PRED,i);
  651.  
  652.     inbuf = EMPTY;                     /* nothing is in our buffer */
  653. }
  654.  
  655. /*  The upd_tab routine is used to add a new entry to the string table.
  656.     As previously stated, no checks are made to ensure that the table
  657.     has any room.  This must be done elsewhere.
  658. */
  659.  
  660. upd_tab(pred,foll)                     /* add an entry to the table */
  661. unsigned int pred;                     /* code for preceeding string */
  662. unsigned int foll;                     /* character which follows string */
  663. {
  664.     struct entry *ep;                  /* pointer to current entry */
  665.  
  666.     /* calculate offset just once */
  667.  
  668.     ep = &string_tab[hash(pred,foll)];
  669.  
  670.     ep->used = TRUE;                   /* this spot is now in use */
  671.     ep->next = 0;                      /* no duplicates after this yet */
  672.     ep->predecessor = pred;            /* note code of preceeding string */
  673.     ep->follower = foll;               /* note char after string */
  674. }
  675.  
  676. /*  This algorithm encoded a file into twelve bit strings (three nybbles).
  677.     The gocode() routine is used to read these strings a byte (or two)
  678.     at a time.
  679. */
  680.  
  681. static gocode(fd)                      /* read in a twelve bit code */
  682. FILE *fd;                              /* file to get code from */
  683. {
  684.     unsigned int localbuf, returnval;
  685.  
  686.     if(inbuf==EMPTY)                   /* if on a code boundary */
  687.     {    if((localbuf=getc_unp(fd))==EOF)   /* get start of next code */
  688.               return EOF;              /* pass back end of file status */
  689.          localbuf &= 0xFF;             /* mask down to true byte value */
  690.          if((inbuf=getc_unp(fd))==EOF) /* get end of code, start of next */
  691.               return EOF;              /* this should never happen */
  692.          inbuf &= 0xFF;                /* mask down to true byte value */
  693.  
  694.          returnval = ((localbuf<<4)&0xFF0) + ((inbuf>>4)&0x00F);
  695.          inbuf &= 0x000F;              /* leave partial code pending */
  696.     }
  697.  
  698.     else                               /* buffer contains first nybble */
  699.     {    if((localbuf=getc_unp(fd))==EOF)
  700.               return EOF;
  701.          localbuf &= 0xFF;
  702.  
  703.          returnval = localbuf + ((inbuf<<8)&0xF00);
  704.          inbuf = EMPTY;                /* note no hanging nybbles */
  705.     }
  706.     return returnval;                  /* pass back assembled code */
  707. }
  708.  
  709. static push(c)                         /* push char onto stack */
  710. int c;                                 /* character to push */
  711. {
  712.     stack[sp] = ((char) c);            /* coerce integer into a char */
  713.  
  714.     if(++sp >= TABSIZE)
  715.          abort("Stack overflow\n");
  716. }
  717.  
  718. static int pop()                       /* pop character from stack */
  719. {
  720.     if(sp>0)
  721.          return ((int) stack[--sp]);   /* leave ptr at next empty slot */
  722.  
  723.     else return EMPTY;
  724. }
  725.  
  726. /***** LEMPEL-ZEV DECOMPRESSION *****/
  727.  
  728. static int code_count;                 /* needed to detect table full */
  729. static unsigned code;                  /* where we are so far */
  730. static int firstc;                     /* true only on first character */
  731.  
  732. init_ucr(new)                          /* get set for uncrunching */
  733. int new;                               /* true to use new hash function */
  734. {
  735.     if(new)                            /* set proper hash function */
  736.          h = newh;
  737.     else h = oldh;
  738.  
  739.     sp = 0;                            /* clear out the stack */
  740.     init_tab();                        /* set up atomic code definitions */
  741.     code_count = TABSIZE - 256;        /* note space left in table */
  742.     firstc = 1;                        /* true only on first code */
  743. }
  744.  
  745. int getc_ucr(f)                        /* get next uncrunched byte */
  746. FILE *f;                               /* file containing crunched data */
  747. {
  748.     unsigned int c;                    /* a character of input */
  749.     int code, newcode;
  750.     static int oldcode, finchar;
  751.     struct entry *ep;                  /* allows faster table handling */
  752.  
  753.     if(firstc)                         /* first code is always known */
  754.     {    firstc = FALSE;               /* but next will not be first */
  755.          oldcode = gocode(f);
  756.          return finchar = string_tab[oldcode].follower;
  757.     }
  758.  
  759.     if(!sp)                            /* if stack is empty */
  760.     {    if((code=newcode=gocode(f))==EOF)
  761.               return EOF;
  762.  
  763.          ep = &string_tab[code];       /* initialize pointer */
  764.  
  765.          if(!ep->used)                 /* if code isn't known */
  766.          {    code = oldcode;
  767.               ep = &string_tab[code];  /* re-initialize pointer */
  768.               push(finchar);
  769.          }
  770.  
  771.          while(ep->predecessor!=NO_PRED)
  772.          {    push(ep->follower);      /* decode string backwards */
  773.               code = ep->predecessor;
  774.               ep = &string_tab[code];
  775.          }
  776.  
  777.          push(finchar=ep->follower);   /* save first character also */
  778.  
  779.          /*   The above loop will terminate, one way or another,
  780.               with string_tab[code].follower equal to the first
  781.               character in the string.
  782.          */
  783.  
  784.          if(code_count)                /* if room left in string table */
  785.          {    upd_tab(oldcode,finchar);
  786.               --code_count;
  787.          }
  788.  
  789.          oldcode = newcode;
  790.     }
  791.  
  792.     return pop();                      /* return saved character */
  793. }
  794.